home *** CD-ROM | disk | FTP | other *** search
/ The PC-SIG Library 9 / The PC-SIG Library on CD ROM - Ninth Edition.iso / 2401_500 / DISK2468 / DISK2468.ZIP / MM / POPUP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-05  |  13.1 KB  |  400 lines
  1. /********************************************************************
  2.  *       Popup window toolkit for Turbo C (popup.c)                 *
  3.  ********************************************************************/
  4. #include <stddef.h>
  5. #include <stdarg.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <alloc.h>
  9. #include <conio.h>
  10. #include <string.h>
  11. #include <process.h>
  12. #include "\tc\myincs\popup.h"
  13. #include "\tc\myincs\mouse.h"
  14. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  15. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  16. /*
  17.  *    Global data definitions
  18.  */
  19. windesc *base_win = NULL;    /* The "Base Window" pointer */
  20. windesc *curr_win = NULL;    /* The current window pointer */
  21.  
  22. /* Color sets for color monitors                                    */
  23. /* {border_type, border_color, text_color, title_color, hilite_color} */
  24. wincolors defcolors =    {1,  23,  30,  27,  94 };
  25. wincolors invcolors =    {1, 112, 112, 112,  15 };
  26. wincolors monocolors =    {1,   7,  15,  15,  12 };
  27. wincolors errcolors =    {1,  79,  79,  79,   4 };
  28. wincolors msgcolors =    {1,  47,  47,  46, 112 };
  29. wincolors graycolors =    {1, 116, 127, 127, 127 };
  30.  
  31. /* variables internal to popup.c */
  32. static windesc *top_win;    /* window stack pointer */
  33. static void chg_win(windesc *this);
  34. static windesc *make_window_node(void);
  35. static windesc *push_window_node(void);
  36. static void dispose_window_node(windesc *w);
  37.  
  38. void init_win(void)
  39. /*    init_win initializes the internal variables for the popup windows
  40.     package.  This function creates a base window "base_win" which
  41.     represents the entire screen.
  42.     This function MUST be called before any popup routines are used. */
  43. {
  44.     struct text_info ti;        /* Turbo C predefined structure */
  45.  
  46.     base_win = make_window_node();    /* allocate a window node */
  47.     gettextinfo(&ti);                        /* get base window coords */
  48.     base_win->xul = ti.winleft - 1;    /* but our coords include border ! */
  49.     base_win->xlr = ti.winright + 1;
  50.     base_win->yul = ti.wintop - 1;
  51.     base_win->ylr = ti.winbottom + 1;
  52.     base_win->wd  = ti.screenwidth + 2;
  53.     base_win->ht  = ti.screenheight + 2;
  54.     base_win->xsave = ti.curx;
  55.     base_win->ysave = ti.cury;
  56.     base_win->wc    = monocolors;                /* default to monochrome colors */
  57.     base_win->wc.text_color = ti.attribute;/* but use current window color */
  58.     base_win->name = "base";                    /* window has no title */
  59.     base_win->wtype = tile;                        /* no saved image underneath */
  60.     base_win->wc.border_type = 0;                /* has no border either */
  61.     top_win = base_win;                            /* set up window stack */
  62.     curr_win = base_win;
  63. }
  64.  
  65. windesc *draw_win(int x,int y,int wd, int ht, char *title,
  66.                         enum windowtype wt, wincolors *wc)
  67. /*    draw_win creates a new window at a designated screen location.
  68.     All window coordinates include the border!  Note that the
  69.     turbo-C window funciton does not know about the border, and that
  70.     its coordinates are actually "inside" the border.
  71.     Besides the usual coordinates for (x,y), you can use the following
  72.     codes:
  73.         x = CTRWIN    (Center window in x direction)
  74.         y = CTRWIN    (Center window in y direction)
  75. */
  76. {
  77.     windesc *w;
  78.     int xsave, ysave;
  79.     mouse_off(1);                /* hide mouse cursor during screen updates */
  80.     w = push_window_node();    /* create and link up a window node */
  81.  
  82.     /* check for valid window size */
  83.     wd = MAX(wd,3);
  84.     wd = MIN(wd,80);
  85.     ht = MAX(ht,3);
  86.     ht = MIN(ht,25);
  87.  
  88.     /* check for centering coordinates and current coordinates.
  89.         Reminder: these are absolute coordinates ! */
  90.     if (x == CTRWIN) x = (80-wd) /2;
  91.     if (y == CTRWIN) y = (25-ht) /2;
  92.  
  93.     /* Check for valid coordinates.  Coordinates (0,0) are valid only for
  94.         borderless windows, (the actual window will start at (1,1)). */
  95.     if (wc->border_type) {
  96.         x = MAX(x,1);
  97.         y = MAX(y,1);
  98.     }
  99.     else {
  100.         x = MAX(x,0);
  101.         y = MAX(y,0);
  102.     }
  103.     if ((x+wd) > 80) x = 80-wd+1;
  104.     if ((y+ht) > 25) y = 25-ht+1;
  105.  
  106.     /* store the window parameters */
  107.     w->wd = wd; w->ht = ht; w->xul = x; w->yul = y;
  108.     w->xlr = x + w->wd-1; w->ylr = w->yul + w->ht -1;
  109.     w->wc = *wc;    /* set up our set of colors */
  110.     w->xsave = 1;    w->ysave = 1;
  111.     w->wtype = wt;    w->name = strdup(title);
  112.  
  113.     /* allocate and save image underneath if a popup window */
  114.     if (wt == popup) {
  115.         w->image = calloc(wd*ht,2);
  116.         swap_image(w);
  117.     }
  118.  
  119.     /* Ready to draw box and title.  To do this we must be in base or
  120.         "absolute" coords.  But we must be careful to save the base cursor
  121.         coords cause draw box and centerstr will change them on us. */
  122.     if (curr_win == base_win) {
  123.         xsave = wherex();
  124.         ysave = wherey();
  125.     }
  126.     else {
  127.         xsave = base_win->xsave;
  128.         ysave = base_win->ysave;
  129.     }
  130.     chg_win(base_win);
  131.     draw_box(w->xul,w->yul,w->xlr,w->ylr,w->wc.border_type,w->wc.border_color);
  132.     centerstr(w->xul,w->yul,w->xlr,w->yul,w->name,w->wc.title_color);
  133.     gotoxy(xsave,ysave);        /* restore base window cursor coords */
  134.     chg_win(w);                    /* Now select new window */
  135.     clr_win();                    /* and clear it */
  136.     mouse_on(1);                /* restore mouse state */
  137.     return w;                    /* return new window pointer */
  138. }
  139.  
  140. void view_win(windesc *this, int select)
  141. /*    If select = 1, then view_win moves "this" window to the
  142.     top of the stack and makes it the active window.
  143.     If select = 0, then the window is removed from the stack and erased.
  144.     Node that no moves take place if already at the top.
  145.     If this is merely a tiled window, then it is just selected. */
  146. {
  147.     windesc *p;
  148.     if (select && this == top_win) return;
  149.     mouse_off(1);        /* make sure mouse is hidden */
  150.  
  151.     /* if this is a popup window, move its image to the top */
  152.     if (this->wtype == popup) {
  153.         p = top_win;
  154.         while (p != this) {        /* hide all window above */
  155.             swap_image(p);
  156.             p = p->under;
  157.         }
  158.         swap_image(this);            /* and then this window */
  159.         p = this;               /* then put rest of windows back */
  160.         while(p != top_win) {
  161.             p = p->over;
  162.             swap_image(p);
  163.         }
  164.     }
  165.  
  166.     /* link up window underneath this one, with the window above it */
  167.     if (this == top_win) {        /* if this == top_win here, then it is also */
  168.         this->under->over = NULL; /* true that we're removing it for good */
  169.         top_win = this->under;
  170.     }
  171.     else {
  172.         this->under->over = this->over;
  173.         this->over->under = this->under;
  174.     }
  175.     if (select) {
  176.         top_win->over = this;  /* move window to the top */
  177.         this->under = top_win;
  178.         top_win = this;
  179.         swap_image(this);        /* put back it's image.  Does nothing if tiled */
  180.         chg_win(this);            /* change window */
  181.     }
  182.     else {
  183.         chg_win(top_win);                /* might as well select top window */
  184.         dispose_window_node(this);    /* but do before free old window */
  185.     }
  186.     mouse_on(1);        /* restore mouse state */
  187. }
  188.  
  189. static void chg_win(windesc *this)
  190. /* internal routine to select a window */
  191. {
  192.     curr_win->xsave = wherex();
  193.     curr_win->ysave = wherey();
  194.     window(this->xul+1, this->yul+1, this->xlr-1, this->ylr-1);
  195.     textattr(this->wc.text_color);    /* restore window color and cursor */
  196.     gotoxy(this->xsave, this->ysave);
  197.     curr_win = this;                        /* selected window is active */
  198. }
  199.  
  200. void swap_image(windesc *w)
  201. /*    This routine swaps the image buffer of a window with what is on the
  202.     screen.  If the window is not a popup window, then nothing happens. */
  203. {
  204.     int xstart, ystart, xfin, yfin;
  205.     char *temp_image;
  206.     unsigned int nbytes;
  207.     if (w->wtype == popup) {
  208.         xstart = w->xul;  ystart = w->yul;
  209.         xfin   = w->xlr;  yfin   = w->ylr;
  210.         if (!w->wc.border_type) {    /* don't swap border area if no border */
  211.             xstart++; ystart++;
  212.             xfin--; yfin--;
  213.         }
  214.         nbytes = (xfin-xstart+1)*(yfin-ystart+1)*2;
  215.         mouse_off(1);        /* hide cursor during screen update */
  216.         temp_image = malloc(nbytes);
  217.         gettext(xstart, ystart, xfin, yfin, temp_image);
  218.         puttext(xstart, ystart, xfin, yfin, (void *)w->image);
  219.         memcpy(w->image, temp_image, nbytes);
  220.         free(temp_image);
  221.         mouse_on(1);        /* restore mouse cursor */
  222.     }
  223. }
  224.  
  225. void clr_win(void)
  226. /*    High level clear window.  Supports the mouse cursor, and uses
  227.     the text_color of the current window when clearing it. */
  228. {
  229.     mouse_off(1);
  230.     textattr(curr_win->wc.text_color);
  231.     clrscr();
  232.     mouse_on(1);
  233. }
  234.  
  235. void mprintf(char *fmt,...)
  236. /*    mprintf is a high level printf-like funciton that calls printf (so it
  237.     knows about the current window), but also takes care of them mouse.
  238.     NOTE:  the formatting must not exceed 255 characters ! */
  239. {
  240.     va_list arg_ptr;
  241.     char t[255];
  242.     va_start(arg_ptr,wd);
  243.     vsprintf(t,fmt,arg_ptr);    /* internal format function */
  244.     mouse_off(1);                    /* hide mouse cursor during screen update */
  245.     cprintf("%s", t);                /* print the string with scrolling supported */
  246.     mouse_on(1);                    /* restore mouse cursor */
  247.     va_end(arg_ptr);
  248. }
  249.  
  250. void prtfstr(int x, int y, char *fmt, unsigned char attr, int wd,...)
  251. /*    prtfstr prints a formatted string in the current window.  prfstr is
  252.     similar to cprintf except that it doesn't support wrap-around, in fact,
  253.     it goes to great lengths to get around it.  If the string is too long
  254.     to fit in the window, it will be truncated.
  255.     If attr != 0, the string will be printed with that color, otherwise
  256.     the color will be left alone.
  257.     If wd < 0 and the length of the formatted string = 1, then prtfstr
  258.     will print the one-character string abs(wd) times.  This is useful
  259.     for filling a line with a character.
  260.     NOTE:  The formatting must not exceed 255 characters ! */
  261. {
  262.     va_list arg_ptr;
  263.     char t[255];
  264.     int len, i, n, xa, ya, fillflag;
  265.     static texel line[80];        /* text image buffer */
  266.     va_start(arg_ptr,wd);
  267.     vsprintf(t, fmt, arg_ptr);    /* internal format function */
  268.     va_end(arg_ptr);
  269.     n = abs(wd);                    /* compute and bounds check desired width */
  270.     n = MIN(n, curr_win->wd-x-1);
  271.     xa = curr_win->xul + x;
  272.     ya = curr_win->yul + y;
  273.     len = MIN(strlen(t), n);    /* keep string inside the window */
  274.     t[len] = 0;                        /* by truncating if necessary */
  275.     if (len) {    /* only do non-null strings */
  276.         if (wd < 0 && (strlen(t) == 1)) {
  277.             fillflag = 1;
  278.             len = n;
  279.         }
  280.     else {
  281.         fillflag = 0;
  282.     }
  283.     mouse_off(1);                                    /* remember to hide mouse */
  284.     gettext(xa, ya, xa+len-1, ya, line);    /* extract text image */
  285.     for (i=0; i<len; i++) {
  286.         if (fillflag) line[i].ch = *t;
  287.             else line[i].ch = t[i];
  288.         if (attr) line[i].attr = attr;
  289.     }
  290.     puttext(xa, ya, xa+len-1, ya, line);    /* put it back */
  291.     mouse_on(1);                                    /* restore mouse */
  292.     if (x+len == curr_win->wd-1)
  293.         x--;                                    /* Keep cursor in window */
  294.         gotoxy(x+len, y);                    /* then move it to end of string */
  295.     }
  296.     else {  /* for null strings, just move cursor */
  297.         gotoxy(x,y);
  298.     }
  299. }
  300.  
  301. void centerstr(int xul, int yul, int xlr, int ylr, char *s, unsigned char a)
  302. /*    centerstr prints a string centered between the relative coord's
  303.     (xul,yul) and (xlr,ylr), with attribute a. */
  304. {
  305.     int xs, ys, wd;
  306.     if (*s != 0) {
  307.         mouse_off(1);
  308.         wd = xlr-xul+1;
  309.         if ((xs = (wd-strlen(s)) / 2 + xul) < xul) xs = xul;
  310.         if ((ys = (ylr-yul+1) / 2 + yul) < yul) ys = yul;
  311.         prtfstr(xs, ys, s, a, wd);
  312.         mouse_on(1);
  313.     }
  314. }
  315.  
  316. void draw_box(int xul, int yul, int xlr, int ylr, int btype, int attr)
  317. /* Draws a box at the upper left (xul,yul) and lower right
  318.     (xlr,ylr) coords with given attribute.  If btype = 0, no box is drawn,
  319.     if btype = 1, a single line box is drawn, if btype = 2, a doulble line
  320.     box is drawn.
  321. */
  322. {
  323.     static int boxcar[2][6] =        /* graphics characters for a box */
  324.     {
  325.         {218,196,191,179,192,217},    /* single line box */
  326.         {201,205,187,186,200,188}    /* double line box */
  327.     };
  328.     int i, hzchar, vtchar, oldattr;
  329.     texel t;
  330.     struct text_info ti;
  331.     if (btype)
  332.     {
  333.         mouse_off(1);
  334.         gettextinfo(&ti);        /* save old text attribute */
  335.         oldattr = ti.attribute;
  336.         textattr(attr);
  337.         hzchar = boxcar[btype-1][1];
  338.         vtchar = boxcar[btype-1][3];
  339.         /* draw top and bottom sides */
  340.         gotoxy(xul+1,yul);
  341.         for (i = xul+1; i < xlr; i++) putch(hzchar);
  342.         gotoxy(xul+1,ylr);
  343.         for (i = xul+1; i < xlr; i++) putch(hzchar);
  344.         /* draw vertical sides */
  345.         for (i = yul+1; i < ylr; i++)
  346.         {
  347.             gotoxy(xul,i);
  348.             putch(vtchar);
  349.             gotoxy(xlr,i);
  350.             putch(vtchar);
  351.         }
  352.         /* draw corners */
  353.         gotoxy(xul,yul); putch(boxcar[btype-1][0]); /* upper left */
  354.         gotoxy(xlr,yul); putch(boxcar[btype-1][2]); /* upper right */
  355.         gotoxy(xul,ylr); putch(boxcar[btype-1][4]); /* lower left */
  356.         /* can't write lower right corner via putch, due to possible
  357.             scroll problems, so must do it a roundabout way */
  358.         gettext(xlr,ylr,xlr,ylr,&t);
  359.         t.ch = boxcar[btype-1][5];
  360.         t.attr = attr;
  361.         puttext(xlr,ylr,xlr,ylr,&t);
  362.         textattr(oldattr);    /* restore old attribute */
  363.         mouse_on(1);
  364.     }
  365. }
  366.  
  367. static windesc *make_window_node(void)
  368. /*    make_window_node allocates room for a new window structure,
  369.     and initializes it's links to NULL. */
  370. {
  371.     windesc *q;
  372.     q = (windesc *)malloc(sizeof(windesc));
  373.     q->image = NULL;
  374.     q->under = NULL;
  375.     q->over  = NULL;
  376.     return q;
  377. }
  378.  
  379. static windesc *push_window_node(void)
  380. /* push_window_node "pushes" the window w onto the window stack. */
  381. {
  382.     windesc *q;
  383.     q = make_window_node();        /* allocate a window node */
  384.     top_win->over = q;            /* link top of stack to new node */
  385.     q->under = top_win;            /* link lew node to top of stack */
  386.     top_win = q;                    /* set top of stack to new node */
  387.     return q;
  388. }
  389.  
  390. static void dispose_window_node(windesc *w)
  391. /*    Dispose_window_node frees up the image save area of the window,
  392.     and the window structure itself. */
  393. {
  394.     if (w != NULL) {        /* savety test for base window */
  395.         if (w->wtype == popup) free(w->image);
  396.         free(w->name);        /* free up window title */
  397.         free(w);                /* and then the structure itself */
  398.     }
  399. }
  400.